/**
 * 分割等和子集
 *
 * 描述
 * 给定一个只包含正整数的数组 nums ，请问能否把这个数组取出若干个数使得取出的数之和和剩下的数之和相同。
 *
 * 数据范围：1≤n≤500,
 * 数组中的元素满足 1≤numsi≤100
 *
 * 输入描述：
 * 第一行输入一个正整数 n ，表示数组 nums 的长度。
 * 第二行输入 n 个正整数，表示数组中的值。
 *
 * 输出描述：
 * 如果满足题目条件，输出 true ，否则输出 false
 */

import java.util.Scanner;

/**
 * 这里我们可以使用动态规划, 原来的题目换一种理解
 * 可以看成是, 从 n 个 是否能选出和为 target 的
 * 几个数, 那么这就可以看成是 0, 1背包了.
 * dp[i][j] : i 个数中能否选出等于 j 的几个数
 * 分为两种情况 :
 *      1. 不选 nums[i - 1] : dp[i][j] = dp[i - 1][j]
 *      2.  选 nums[i - 1] : dp[i][j] = dp[i - 1][j - nums[i - 1]]
 *      但是选的情况下可能会是数组越界, 所以我们在选之前要先判断下数组是否越界
 * 时间复杂度 : O(n * target)
 * 空间复杂度 : O(n * target)
 */

public class Main {
    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        int n = in.nextInt();

        int[] nums = new int[n];

        // 数组总和
        int sum = 0;

        for (int i = 0; i < n; i++) {
            nums[i] = in.nextInt();
            sum += nums[i];
        }

        if (sum % 2 != 0) {

            // 要是数组不是 2 的倍数, 那么返回 false
            System.out.println("false");
        } else {

            // 这里目标是 sum / 2
            int target = sum / 2;

            // 从 n 个数中能否选出和等于 target 的几个数
            boolean[][] dp = new boolean[n + 1][target + 1];
            // i 个数中能否选出等于 j 的几个数
            // dp[i][j] = dp[i - 1][j]
            // dp[i][j] = dp[i - 1][j - nums[i - 1]]

            // 初始话, 0 个数理选出 0, 那么自然是可以的
            dp[0][0] = true;

            // 状态转移
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= target; j++) {

                    // 不选 nums[i - 1] 这个数
                    dp[i][j] = dp[i - 1][j];

                    // 在符合条件的情况下, 选 nums[i - 1] 这个数
                    if (j - nums[i - 1] >= 0) {
                        dp[i][j] |= dp[i - 1][j - nums[i - 1]];
                    }
                }
            }

            // 打印 结果
            System.out.println(dp[n][target]);
        }
    }
}